package com.winai.launcher;

import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.text.TextUtils;
import android.util.Log;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.ks.projectbasictools.retrofit.HttpResponseListener;
import com.winai.launcher.bean.requestBean.UseInfoBean;
import com.winai.launcher.bean.responseEntity.UseInfoEntity;
import com.winai.launcher.constant.HttpUrls;
import com.winai.launcher.utils.ACache;
import com.winai.launcher.utils.SPUtils;
import com.winai.launcher.utils.ServerUtils;

import org.json.JSONArray;
import org.json.JSONException;

import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

import okhttp3.ResponseBody;
import retrofit2.Call;

/**
 * 作者：康少
 * 时间：2020/4/13 0013
 * 说明：数据发送前准备接口，封装环境数据
 */
public class DataSender {
    public final String TAG = "zhxk用户行为统计 DataSender";

    /**
     * 行为Json列表
     */
    private List<UseInfoBean> mActionArray;

    private ACache aCache;

    /**
     * 初始化DataSender
     */
    public DataSender(Context application) {
        aCache = ACache.get(application.getApplicationContext());
    }

    /**
     * 发送数据接口
     *
     * @param array json动作列表
     */
    public void sendData(List<UseInfoBean> array) {
        //判断本地是否有数据
        HashSet set = SPUtils.getSet();
        if (null != set) {
            for (Iterator<String> iter = set.iterator(); iter.hasNext(); ) {
                String str = iter.next();
                Log.d(TAG, "本地行为数据key：" + str);
                JSONArray asJSONObject = aCache.getAsJSONArray(str);
                if (null != asJSONObject) {
                    Log.d(TAG, "本地发送的行为数据 = " + asJSONObject);
                    List<UseInfoBean> s = new Gson().fromJson(asJSONObject.toString(), new TypeToken<List<UseInfoBean>>() {
                    }.getType());
                    send(s, str);
                }
            }
        }
        //
        mActionArray = array;
        //发送数据
        Log.d(TAG, "最终发送的数据 = " + mActionArray);
        //这里联网请求数据
        send(mActionArray, "");
    }

    //发送 自己些网络发送的数据
    private void send(List<UseInfoBean> jsonData, String key) {
        Log.d(TAG, "看下几次 key = " + key);
        MySend mySend = new MySend(jsonData, key);
        Thread thread = new Thread(mySend);
        thread.start();
    }

    /**
     * 获取application中指定的meta-data 调用方法时key就是UMENG_CHANNEL
     *
     * @return 如果没有获取成功(没有对应值 ， 或者异常)，则返回值为空
     */
    public static String getAppMetaData(Context ctx, String key) {
        if (ctx == null || TextUtils.isEmpty(key)) {
            return null;
        }
        String resultData = "";
        try {
            PackageManager packageManager = ctx.getPackageManager();
            if (packageManager != null) {
                ApplicationInfo applicationInfo = packageManager.getApplicationInfo(ctx.getPackageName(), PackageManager.GET_META_DATA);
                if (applicationInfo != null) {
                    if (applicationInfo.metaData != null) {
                        resultData = applicationInfo.metaData.getString(key);
                    }
                }

            }
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }

        return resultData;
    }

    //模拟发送网络请求
    class MySend implements Runnable {
        //自己定义的 上传成功或者失败
        boolean isSuccess = false;
        List<UseInfoBean> jsonData;
        String key;

        public MySend(List<UseInfoBean> jsonData, String key) {
            this.jsonData = jsonData;
            this.key = key;
        }

        @Override
        public void run() {

            ServerUtils.requestJsonPost(HttpUrls.USEINFO_SAVE, null, jsonData, new HttpResponseListener<UseInfoEntity>() {
                @Override
                public void onResponse(UseInfoEntity var1, boolean isCache) {
                    if (isCache) {
                        return;
                    }
                    isSuccess = var1.isData();
                    parseResult();
                }

                @Override
                public void onFailure(Call<ResponseBody> call, Throwable e) {
                    isSuccess = false;
                    parseResult();
                }

                @Override
                public void onError(int code, String msg) {
                    isSuccess = false;
                    parseResult();
                }
            });
        }

        private void parseResult() {
            if (isSuccess) {
                if (TextUtils.isEmpty(key)) {
                    // 上传成功,不是本地上传的 不用管
                    Log.d(TAG, "上传成功 不是本地数据不用管");
                } else {
                    //上传成功 并且是本地上传的
                    //删除本地数据
                    Log.d(TAG, "上传成功 删除本地数据");
                    SPUtils.remove(com.winai.launcher.Application.getContext(), key);
                    aCache.remove(key);
                }
            } else {
                if (TextUtils.isEmpty(key)) {
                    // 上传不成功,不是本地上传的  存储
                    long time = System.currentTimeMillis();
                    SPUtils.addSet(String.valueOf(time));
                    String s = new Gson().toJson(jsonData, new TypeToken<List<UseInfoBean>>() {
                    }.getType());
                    try {
                        JSONArray jsonArray = new JSONArray(s);
                        aCache.put(String.valueOf(time), jsonArray);
                        Log.d(TAG, "上传不成功,不是本地上传的  存储");
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                } else {
                    // 上传不成功,是本地上传的  不用管
                    Log.d(TAG, "上传不成功,是本地上传的  不用管");
                }
            }
        }
    }
}
